home *** CD-ROM | disk | FTP | other *** search
/ Aminet 22 / Aminet 22 (1997)(GTI - Schatztruhe)[!][Dec 1997].iso / Aminet / dev / src / ConfigFileSrc.lha / ConfigFileSrc12 / Library / Funcs / Clone.c < prev    next >
Encoding:
Text File  |  1997-10-02  |  5.4 KB  |  229 lines
  1. /*
  2. **        $PROJECT: ConfigFile.library
  3. **        $FILE: Clone.c
  4. **        $DESCRIPTION: cf_Clone#?() functions
  5. **
  6. **        (C) Copyright 1996-1997 Marcel Karas
  7. **             All Rights Reserved.
  8. */
  9.  
  10. IMPORT struct ExecBase    * SysBase;
  11.  
  12. /****** configfile.library/cf_CloneArgument **********************************
  13. *
  14. *   NAME
  15. *        cf_CloneArgument -- Copy an argument node with all item nodes.
  16. *
  17. *   SYNOPSIS
  18. *        NewArgNode = cf_CloneArgument(ArgNode);
  19. *        D0                            A0
  20. *
  21. *        CFArgument * cf_CloneArgument(CFArgument *);
  22. *
  23. *   FUNCTION
  24. *        This function duplicates an argument node with all item nodes.
  25. *        Note the duplicated ArgNode is not added.
  26. *
  27. *   INPUTS
  28. *        ArgNode - The argument node to clone.
  29. *
  30. *   RESULT
  31. *        NewArgNode - The new argument node or NULL by failure.
  32. *
  33. *   EXAMPLE
  34. *        CFGroup    * myGrpNode;
  35. *        CFArgument * myArgNode;
  36. *
  37. *        ...
  38. *        myArgNode = cf_NewArgument (myGrpNode, "ExampleArgument");
  39. *        cf_AddArgument (myGrpNode, cf_CloneArgument (myArgNode));
  40. *        ...
  41. *
  42. *        In the CF file:
  43. *
  44. *        ...
  45. *        [ExampleGroup]
  46. *
  47. *        ...
  48. *        ExampleArgument=
  49. *        ...
  50. *        ExampleArgument=
  51. *        ...
  52. *
  53. *   SEE ALSO
  54. *        cf_CloneGroup(), cf_CloneItem()
  55. *
  56. ******************************************************************************
  57. *
  58. */
  59.  
  60. LibCall iCFArgument * cf_CloneArgument ( REGA0 iCFArgument * ArgNode )
  61. {
  62.     iCFArgument    *NewArgNode;
  63.     iCFItem        *ItemNode;
  64.  
  65.     FuncDe(bug("cf_CloneArgument($%08lx)\n{\n", ArgNode));
  66.  
  67.     ArgNode->GrpNode->Header->Flags |= CF_HFLG_CHANGED;
  68.  
  69.     if ( NewArgNode = NewArg (ArgNode->GrpNode, ArgNode->Name, *(ArgNode->Name - 1)) )
  70.     {
  71.         Remove ((struct Node *) NewArgNode);
  72.         NewArgNode->ExtFlags    |= CF_EFLG_REMOVED;
  73.  
  74.         if ( ItemNode = cf_LockItemList (ArgNode) )
  75.         {
  76.             while ( ItemNode = cf_NextItem (ItemNode) )
  77.                 AddTail ((struct List *) &NewArgNode->ItemList,
  78.                     (struct Node *) cf_CloneItem (ItemNode));
  79.  
  80.             cf_UnlockItemList (ArgNode);
  81.         }
  82.         
  83.         FuncDe(bug("   return($%08lx)\n}\n", NewArgNode));
  84.         return (NewArgNode);
  85.     }
  86.     
  87.     FuncDe(bug("   return(NULL)\n}\n"));
  88.     return (NULL);
  89. }
  90.  
  91. /****** configfile.library/cf_CloneGroup *************************************
  92. *
  93. *   NAME
  94. *        cf_CloneGroup -- Copy a group node with all argument and item nodes.
  95. *
  96. *   SYNOPSIS
  97. *        NewGrpNode = cf_CloneGroup(GrpNode);
  98. *        D0                         A0
  99. *
  100. *        CFGroup * cf_CloneGroup(CFGroup *);
  101. *
  102. *   FUNCTION
  103. *        This function duplicates a group node with all argument and item
  104. *        nodes. Note the duplicated GrpNode is not added.
  105. *
  106. *   INPUTS
  107. *        GrpNode - The group node to clone.
  108. *
  109. *   RESULT
  110. *        NewGrpNode - The new group node or NULL by failure.
  111. *
  112. *   EXAMPLE
  113. *        CFHeader * myHeader;
  114. *        CFGroup  * myGrpNode;
  115. *
  116. *        ...
  117. *        myGrpNode = cf_NewGroup (myHeader, "ExampleGroup");
  118. *        cf_AddGroup (myHeader, cf_CloneGroup (myGrpNode));
  119. *        ...
  120. *
  121. *        In the CF file:
  122. *
  123. *        ...
  124. *        [ExampleGroup]
  125. *        ...
  126. *        [ExampleGroup]
  127. *        ...
  128. *
  129. *   SEE ALSO
  130. *        cf_CloneArgument(), cf_CloneItem()
  131. *
  132. ******************************************************************************
  133. *
  134. */
  135.  
  136. LibCall iCFGroup * cf_CloneGroup ( REGA0 iCFGroup * GrpNode )
  137. {
  138.     iCFGroup        *NewGrpNode;
  139.     iCFArgument    *ArgNode;
  140.  
  141.     FuncDe(bug("cf_CloneGroup($%08lx)\n{\n", GrpNode));
  142.  
  143.     GrpNode->Header->Flags |= CF_HFLG_CHANGED;
  144.  
  145.     if ( NewGrpNode = NewGrp (GrpNode->Header, GrpNode->Name, *(GrpNode->Name - 1)) )
  146.     {
  147.         Remove ((struct Node *) NewGrpNode);
  148.         NewGrpNode->ExtFlags    |= CF_EFLG_REMOVED;
  149.  
  150.         if ( ArgNode = cf_LockArgList (GrpNode) )
  151.         {
  152.             while ( ArgNode = cf_NextArgument (ArgNode) )
  153.                 AddTail ((struct List *) &NewGrpNode->ArgList,
  154.                     (struct Node *) cf_CloneArgument (ArgNode));
  155.             
  156.             cf_UnlockArgList (GrpNode);
  157.         }
  158.  
  159.         FuncDe(bug("   return($%08lx)\n}\n", NewGrpNode));
  160.         return (NewGrpNode);
  161.     }
  162.  
  163.     FuncDe(bug("   return(NULL)\n}\n"));
  164.     return (NULL);
  165. }
  166.  
  167. /****** configfile.library/cf_CloneItem **************************************
  168. *
  169. *   NAME
  170. *        cf_CloneItem -- Copy an item node.
  171. *
  172. *   SYNOPSIS
  173. *        NewItemNode = cf_CloneItem(ItemNode);
  174. *        D0                         A0
  175. *
  176. *        CFItem * cf_CloneItem(CFItem *);
  177. *
  178. *   FUNCTION
  179. *        This function duplicates an item node. Note the duplicated ItemNode
  180. *        is not added.
  181. *
  182. *   INPUTS
  183. *        ItemNode - The item node to clone.
  184. *
  185. *   RESULT
  186. *        NewItemNode - The new item node or NULL by failure.
  187. *
  188. *   EXAMPLE
  189. *        CFArgument * myArgNode;
  190. *        CFItem     * myItemNode;
  191. *
  192. *        ...
  193. *        myItemNode = cf_NewItem (myArgNode, (LONG) "ExampleItem", 
  194. *                        CF_ITYP_STRING, NULL);
  195. *        cf_AddItem (myArgNode, cf_CloneItem (myItemNode));
  196. *        ...
  197. *
  198. *        In the CF file:
  199. *
  200. *        ...
  201. *        [ExampleGroup]
  202. *
  203. *        ...
  204. *        ExampleArgument="ExampleItem","ExampleItem"
  205. *        ...
  206. *
  207. *   SEE ALSO
  208. *        cf_CloneGroup(), cf_CloneArgument()
  209. *
  210. ******************************************************************************
  211. *
  212. */
  213.  
  214. SLibCall iCFItem * cf_CloneItem( REGA0 iCFItem * ItemNode )
  215. {
  216.     iCFItem    *NewItemNode;
  217.  
  218.     FuncDe(bug("cf_CloneItem($%08lx)\n{\n", ItemNode));
  219.  
  220.     NewItemNode = cf_NewItem (ItemNode->ArgNode, ItemNode->Contents.Number,
  221.             ItemNode->Type, ItemNode->SpecialType);
  222.  
  223.     Remove ((struct Node *) NewItemNode);
  224.     NewItemNode->ExtFlags    |= CF_EFLG_REMOVED;
  225.  
  226.     FuncDe(bug("   return($%08lx)\n}\n", NewItemNode));
  227.     return (NewItemNode);
  228. }
  229.